package com.vrv.common.resolver.remote;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONStringer;

import android.util.Log;

/**
 * JSON序列化辅助类
 */
public class JSONHelper {

    /**
     * 将对象转换成Json字符串
     */
    public static String toJSON(Object obj) {
        JSONStringer js = new JSONStringer();
        serialize(js, obj);
        return js.toString();
    }

    /**
     * 序列化为JSON
     */
    private static void serialize(JSONStringer js, Object o) {
        if (isNull(o)) {
            try {
                js.value(null);
            } catch (JSONException e) {
                e.printStackTrace();
            }
            return;
        }
        Class<?> clazz = o.getClass();
        if (isObject(clazz)) { // 对象
            serializeObject(js, o);
        } else if (isArray(clazz)) { // 数组
            serializeArray(js, o);
        } else if (isCollection(clazz)) { // 集合
            Collection<?> collection = (Collection<?>) o;
            serializeCollect(js, collection);
        } else { // 单个值
            try {
                js.value(o);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 序列化数组
     **/
    private static void serializeArray(JSONStringer js, Object array) {
        try {
            js.array();
            for (int i = 0; i < Array.getLength(array); ++i) {
                Object o = Array.get(array, i);
                serialize(js, o);
            }
            js.endArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 序列化集合
     **/
    private static void serializeCollect(JSONStringer js, Collection<?> collection) {
        try {
            js.array();
            for (Object o : collection) {
                serialize(js, o);
            }
            js.endArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 序列化对象
     *
     * **/
    private static void serializeObject(JSONStringer js, Object obj) {
        try {
            js.object();
            for (Field f : obj.getClass().getFields()) {
                Object o = f.get(obj);
                if (o != null) {
                    js.key(f.getName());
                    if (isMap(o.getClass())) {
                        serialize(js, getMapValue(o));
                    } else {
                        serialize(js, o);
                    }
                } else {
                    // js.value("");
                }
            }
            js.endObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @SuppressWarnings("rawtypes")
    public static JSONObject getMapValue(Object obj) {
        Map map = (Map) obj;
        Iterator iter = map.entrySet().iterator();
        JSONObject holder = new JSONObject();
        while (iter.hasNext()) {
            Map.Entry pairs = (Map.Entry) iter.next();
            String key = (String) pairs.getKey();
            try {
                holder.put(key, pairs.getValue());
            } catch (JSONException e) {
                Log.e("getMapValue出错：" + e.getMessage(), String.valueOf(obj));
                e.printStackTrace();
            }
        }
        return holder;
    }

    /**
     * 反序列化简单对象
     *
     * @throws
     **/
    public static <T> T parseObject(JSONObject jo, Class<T> clazz) {
        if (clazz == null || isNull(jo)) {
            return null;
        }
        T obj = createInstance(clazz);
        if (obj == null) {
            return null;
        }

        Field[] fields = obj.getClass().getDeclaredFields();

        for (Field f : fields) {
            f.setAccessible(Boolean.TRUE);
            setField(obj, f, jo);
        }
        return obj;
    }

    /**
     * 反序列化简单对象
     *
     * @throws
     **/
    public static <T> T parseObject(String jsonString, Class<T> clazz) {
        if (clazz == null || jsonString == null || jsonString.length() == 0) {
            return null;
        }
        JSONObject jo = null;
        try {
            jo = new JSONObject(jsonString);
        } catch (JSONException e) {
            Log.e("对象转换出错：" + jsonString, clazz.getName());
            e.printStackTrace();
        }
        if (isNull(jo)) {
            return null;
        }
        return parseObject(jo, clazz);
    }

    /**
     * 反序列化数组对象
     *
     * @throws
     **/
    public static <T> T[] parseArray(JSONArray ja, Class<T> clazz) {
        if (clazz == null || isNull(ja)) {
            return null;
        }
        int len = ja.length();
        @SuppressWarnings("unchecked")
        T[] array = (T[]) Array.newInstance(clazz, len);
        for (int i = 0; i < len; ++i) {
            try {
                JSONObject jo = ja.getJSONObject(i);
                T o = parseObject(jo, clazz);
                array[i] = o;
            } catch (JSONException e) {
                Log.e("集合转换出错：" + ja, clazz.getName());
                e.printStackTrace();
            }
        }
        return array;
    }

    /**
     * 反序列化数组对象
     *
     * @throws
     **/
    public static <T> T[] parseArray(String jsonString, Class<T> clazz) {
        if (clazz == null || jsonString == null || jsonString.length() == 0) {
            return null;
        }
        JSONArray jo = null;
        try {
            jo = new JSONArray(jsonString);
        } catch (JSONException e) {
            Log.e("集合转换出错：", jsonString);
            e.printStackTrace();
        }
        if (isNull(jo)) {
            return null;
        }
        return parseArray(jo, clazz);
    }

    /**
     * 反序列化泛型集合
     *
     * @throws
     **/
    @SuppressWarnings("unchecked")
    public static <T> Collection<T> parseCollection(JSONArray ja, Class<?> collectionClazz, Class<T> genericType) {
        if (collectionClazz == null || genericType == null || isNull(ja)) {
            return null;
        }
        Collection<T> collection = (Collection<T>) createInstance(collectionClazz);
        for (int i = 0; i < ja.length(); ++i) {
            try {
                JSONObject jo = ja.getJSONObject(i);
                T o = parseObject(jo, genericType);
                collection.add(o);
            } catch (JSONException e) {
                Log.e("集合转换出错：", ja.toString());
                e.printStackTrace();
            }
        }
        return collection;
    }

    /**
     * 反序列化泛型集合
     *
     * @throws
     **/
    public static <T> Collection<T> parseCollection(String jsonString, Class<?> collectionClazz, Class<T> genericType) {
        if (collectionClazz == null || genericType == null || jsonString == null || jsonString.length() == 0) {
            return null;
        }
        JSONArray jo = null;
        try {
            jo = new JSONArray(jsonString);
        } catch (JSONException e) {
            Log.e("集合转换出错：", jsonString);
            e.printStackTrace();
        }
        if (isNull(jo)) {
            return null;
        }
        return parseCollection(jo, collectionClazz, genericType);
    }

    /** 根据类型创建对象 **/
    private static <T> T createInstance(Class<T> clazz) {
        if (clazz == null)
            return null;
        T obj = null;
        try {
            obj = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            Log.e("createInstance出错：" + e.getMessage(), clazz.getName());
        }
        return obj;
    }

    /** 设定字段的值 **/
    private static void setField(Object obj, Field f, JSONObject jo) {
        String name = f.getName();
        Class<?> clazz = f.getType();
        String toGenericString = f.toGenericString();
        toGenericString.toString();
        try {
            if (isArray(clazz)) { // 数组
                Class<?> c = clazz.getComponentType();
                JSONArray ja = jo.optJSONArray(name);
                if (!isNull(ja)) {
                    Object array = parseArray(ja, c);
                    f.set(obj, array);
                }
            } else if (isCollection(clazz)) { // 泛型集合
                // 获取定义的泛型类型
                Class<?> c = null;
                Type gType = f.getGenericType();
                if (gType instanceof ParameterizedType) {
                    ParameterizedType ptype = (ParameterizedType) gType;
                    Type[] targs = ptype.getActualTypeArguments();
                    if (targs != null && targs.length > 0) {
                        Type t = targs[0];
                        c = (Class<?>) t;
                    }
                }
                JSONArray ja = jo.optJSONArray(name);
                if (!isNull(ja)) {
                    Object o = parseCollection(ja, clazz, c);
                    f.set(obj, o);
                }
            } else if (isSingle(clazz)) { // 值类型
                Object o = jo.opt(name);
                if (o != null) {
                    f.set(obj, o);
                }
            } else if (isObject(clazz)) { // 对象
                JSONObject j = jo.optJSONObject(name);
                if (!isNull(j)) {
                    Object o = parseObject(j, clazz);
                    f.set(obj, o);
                }
            } else {
                throw new Exception("unknow type!");
            }
        } catch (Exception e) {
            Log.e("赋值出错：field=" + f.getName() + ",obj=" + obj.getClass().getSimpleName(), "异常信息：" + e.getMessage());
            e.printStackTrace();
        }
    }

    /** 判断对象是否为空 **/
    public static boolean isNull(Object obj) {
        if (obj instanceof JSONObject) {
            return JSONObject.NULL.equals(obj);
        }
        return obj == null;
    }

    /** 判断是否是值类型 **/
    private static boolean isSingle(Class<?> clazz) {
        return isBoolean(clazz) || isNumber(clazz) || isString(clazz);
    }

    /** 是否布尔值 **/
    public static boolean isBoolean(Class<?> clazz) {
        return (clazz != null) && ((Boolean.TYPE.isAssignableFrom(clazz)) || (Boolean.class.isAssignableFrom(clazz)));
    }

    /** 是否数值 **/
    public static boolean isNumber(Class<?> clazz) {
        return (clazz != null)
                && ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz)) || (Integer.TYPE.isAssignableFrom(clazz))
                        || (Long.TYPE.isAssignableFrom(clazz)) || (Float.TYPE.isAssignableFrom(clazz)) || (Double.TYPE.isAssignableFrom(clazz)) || (Number.class
                            .isAssignableFrom(clazz)));
    }

    /** 判断是否是字符串 **/
    public static boolean isString(Class<?> clazz) {
        return (clazz != null)
                && ((String.class.isAssignableFrom(clazz)) || (Character.TYPE.isAssignableFrom(clazz)) || (Character.class.isAssignableFrom(clazz)));
    }

    /** 判断是否是对象 **/
    private static boolean isObject(Class<?> clazz) {
        return clazz != null && !isSingle(clazz) && !isArray(clazz) && !isCollection(clazz) && !isJSONObject(clazz);
    }

    /** 判断是否是数组 **/
    public static boolean isMap(Class<?> clazz) {
        return clazz != null && Map.class.isAssignableFrom(clazz);
    }

    /** 判断是否是JSON对象 **/
    public static boolean isJSONObject(Class<?> clazz) {
        return clazz != null && JSONObject.class.isAssignableFrom(clazz);
    }

    /** 判断是否是数组 **/
    public static boolean isArray(Class<?> clazz) {
        return clazz != null && clazz.isArray();
    }

    /** 判断是否是集合 **/
    public static boolean isCollection(Class<?> clazz) {
        return clazz != null && Collection.class.isAssignableFrom(clazz);
    }
}